/**
 * 文件名: src/store/index.ts
 * 
 * 文件概述:
 * Zustand状态管理，统一管理全局状态和状态更新方法，处理组件间数据流。
 * 新增多文件参考功能，支持AI对话参考多个章节。
 * 
 * 依赖项:
 * - zustand: 状态管理库
 * - ../utils/platform: 平台操作(getChapters, saveChapter, callAI)
 * 
 * 类型定义:
 * - Chapter: { id: string; title: string; content: string }
 * - Message: { id: string; user: string; ai: string; timestamp: number; references?: string[] }
 * - ReferenceFile: { id: string; title: string; content: string; selected: boolean }
 * - AppState: 应用全局状态接口
 * 
 * 状态定义:
 * - chapters: Chapter[] - 章节列表
 * - selectedChapter: Chapter | null - 当前选中章节
 * - editorContent: string - 编辑器内容
 * - messages: Message[] - AI对话历史
 * - referenceFiles: ReferenceFile[] - 当前选中的参考文件列表
 * - isLoading: { [key: string]: boolean } - 各组件加载状态
 * - error: string | null - 全局错误信息
 * 
 * 状态更新方法:
 * - init(): Promise<void> - 初始化应用，加载章节
 * - setChapters(chapters: Chapter[]): void - 更新章节列表
 * - setSelectedChapter(chapter: Chapter | null): void - 选择章节并更新编辑器内容
 * - setEditorContent(content: string): Promise<void> - 更新编辑器内容并保存章节
 * - saveCurrentChapter(): Promise<void> - 保存当前章节内容
 * - addMessage(message: Omit<Message, 'id' | 'timestamp'>): void - 添加消息到对话历史
 * - clearMessages(): void - 清空对话历史
 * - setLoading(key: string, isLoading: boolean): void - 更新加载状态
 * - setError(error: string | null): void - 设置错误信息
 * 
 * // 新增参考文件方法
 * - addReferenceFile(chapter: Chapter): void - 添加参考文件
 * - removeReferenceFile(id: string): void - 移除参考文件
 * - clearReferenceFiles(): void - 清空参考文件
 * - toggleReferenceFile(id: string): void - 切换章节是否作为参考
 * 
 * 中间件/订阅:
 * - 编辑器内容防抖保存(500ms)
 * - 章节选择时自动加载内容
 * 
 * 数据流:
 * - 初始化流程: init() -> platform.getChapters() -> setChapters()
 * - 章节选择流程: setSelectedChapter() -> 更新editorContent
 * - 内容编辑流程: setEditorContent() -> 防抖 -> saveCurrentChapter() -> platform.saveChapter()
 * - AI交互流程: 
 *   1. 选择参考文件 -> toggleReferenceFile() -> 更新referenceFiles
 *   2. 发送请求 -> 构建合并上下文(selectedChapter + referenceFiles) -> platform.callAI()
 *   3. 接收响应 -> addMessage(带references字段) -> 可选插入至editorContent
 * 
 * 持久化:
 * - 章节数据通过platform.ts持久化
 * - 消息历史和参考文件仅保存在内存中
 * 
 * 注意事项:
 * - 使用中间件实现编辑器内容的防抖保存
 * - 确保状态更新方法遵循不可变性原则
 * - 章节内容与编辑器内容保持同步
 * - 提供init()方法用于应用启动时加载数据
 * - referenceFiles状态不应持久化，仅用于当前会话
 * - 消息历史需记录使用的参考文件，便于回溯
 */

import { create } from 'zustand';
import { v4 as uuidv4 } from 'uuid';
import { debounce } from 'lodash';
import { 
  getChapters as fetchChapters, 
  saveChapter as saveChapterToPlatform,
  callAI as callAIApi
} from '../utils/platform';

// 章节类型定义
export interface Chapter {
  id: string;
  title: string;
  content: string;
}

// 消息类型定义
export interface Message {
  id: string;
  user: string;
  ai: string;
  timestamp: number;
  references?: string[];
}

// 参考文件类型
export interface ReferenceFile {
  id: string;
  title: string;
  content: string;
  selected: boolean;
}

// 应用全局状态接口
interface AppState {
  // 状态
  chapters: Chapter[];
  selectedChapter: Chapter | null;
  editorContent: string;
  messages: Message[];
  referenceFiles: ReferenceFile[];
  isLoading: { [key: string]: boolean };
  error: string | null;
  
  // 方法
  init: () => Promise<void>;
  setChapters: (chapters: Chapter[]) => void;
  setSelectedChapter: (chapter: Chapter | null) => void;
  setEditorContent: (content: string) => Promise<void>;
  saveCurrentChapter: () => Promise<void>;
  addMessage: (message: Omit<Message, 'id' | 'timestamp'>) => void;
  clearMessages: () => void;
  setLoading: (key: string, isLoading: boolean) => void;
  setError: (error: string | null) => void;
  
  // 参考文件方法
  addReferenceFile: (chapter: Chapter) => void;
  removeReferenceFile: (id: string) => void;
  clearReferenceFiles: () => void;
  toggleReferenceFile: (id: string) => void;
  
  // AI调用方法
  callAI: (prompt: string) => Promise<void>;
}

// 创建状态存储
export const useAppStore = create<AppState>((set, get) => {
  // 创建防抖保存函数
  const debouncedSave = debounce(async () => {
    const { saveCurrentChapter } = get();
    await saveCurrentChapter();
  }, 500);
  
  return {
    // 初始状态
    chapters: [],
    selectedChapter: null,
    editorContent: '',
    messages: [],
    referenceFiles: [],
    isLoading: {},
    error: null,
    
    // 初始化应用
    init: async () => {
      set({ isLoading: { ...get().isLoading, init: true } });
      try {
        const result = await fetchChapters();
        if (result.error) {
          set({ error: result.error });
          return;
        }
        
        if (result.data) {
          set({ chapters: result.data });
        }
      } catch (error) {
        set({ error: error instanceof Error ? error.message : String(error) });
      } finally {
        set({ isLoading: { ...get().isLoading, init: false } });
      }
    },
    
    // 更新章节列表
    setChapters: (chapters: Chapter[]) => {
      set({ chapters });
    },
    
    // 选择章节并更新编辑器内容
    setSelectedChapter: (chapter: Chapter | null) => {
      set({ 
        selectedChapter: chapter,
        editorContent: chapter ? chapter.content : ''
      });
    },
    
    // 更新编辑器内容并触发防抖保存
    setEditorContent: async (content: string) => {
      const { selectedChapter } = get();
      
      if (selectedChapter) {
        set({ 
          selectedChapter: { ...selectedChapter, content },
          editorContent: content 
        });
        
        // 触发防抖保存
        debouncedSave();
      } else {
        set({ editorContent: content });
      }
    },
    
    // 保存当前章节内容
    saveCurrentChapter: async () => {
      const { selectedChapter } = get();
      
      if (!selectedChapter) return;
      
      set({ isLoading: { ...get().isLoading, save: true } });
      try {
        const result = await saveChapterToPlatform(selectedChapter);
        if (result.error) {
          set({ error: result.error });
        }
      } catch (error) {
        set({ error: error instanceof Error ? error.message : String(error) });
      } finally {
        set({ isLoading: { ...get().isLoading, save: false } });
      }
    },
    
    // 添加消息到对话历史
    addMessage: (message: Omit<Message, 'id' | 'timestamp'>) => {
      const newMessage: Message = {
        id: uuidv4(),
        timestamp: Date.now(),
        ...message
      };
      
      set({ messages: [...get().messages, newMessage] });
    },
    
    // 清空对话历史
    clearMessages: () => {
      set({ messages: [] });
    },
    
    // 更新加载状态
    setLoading: (key: string, isLoading: boolean) => {
      set({ isLoading: { ...get().isLoading, [key]: isLoading } });
    },
    
    // 设置错误信息
    setError: (error: string | null) => {
      set({ error });
    },
    
    // 添加参考文件
    addReferenceFile: (chapter: Chapter) => {
      const { referenceFiles } = get();
      
      // 检查是否已存在
      const exists = referenceFiles.some(ref => ref.id === chapter.id);
      if (exists) return;
      
      const newReferenceFile: ReferenceFile = {
        id: chapter.id,
        title: chapter.title,
        content: chapter.content,
        selected: true
      };
      
      set({ referenceFiles: [...referenceFiles, newReferenceFile] });
    },
    
    // 移除参考文件
    removeReferenceFile: (id: string) => {
      const { referenceFiles } = get();
      set({ referenceFiles: referenceFiles.filter(ref => ref.id !== id) });
    },
    
    // 清空参考文件
    clearReferenceFiles: () => {
      set({ referenceFiles: [] });
    },
    
    // 切换章节是否作为参考
    toggleReferenceFile: (id: string) => {
      const { referenceFiles } = get();
      
      set({
        referenceFiles: referenceFiles.map(ref => 
          ref.id === id ? { ...ref, selected: !ref.selected } : ref
        )
      });
    },
    
    // 调用AI接口
    callAI: async (prompt: string) => {
      const { selectedChapter, referenceFiles, addMessage } = get();
      
      set({ isLoading: { ...get().isLoading, ai: true } });
      
      try {
        // 构建合并上下文
        let context = '';
        
        // 当前章节内容
        if (selectedChapter) {
          context += `当前章节 "${selectedChapter.title}":\n${selectedChapter.content}\n\n`;
        }
        
        // 参考文件内容
        const selectedReferences = referenceFiles.filter(ref => ref.selected);
        if (selectedReferences.length > 0) {
          context += '参考文件:\n';
          selectedReferences.forEach(ref => {
            context += `--- ${ref.title} ---\n${ref.content}\n\n`;
          });
        }
        
        // 调用AI API
        const result = await callAIApi(prompt, context);
        
        if (result.error) {
          set({ error: result.error });
          return;
        }
        
        // 添加消息到历史
        addMessage({
          user: prompt,
          ai: result.data || '无响应',
          references: selectedReferences.map(ref => ref.id)
        });
      } catch (error) {
        set({ error: error instanceof Error ? error.message : String(error) });
      } finally {
        set({ isLoading: { ...get().isLoading, ai: false } });
      }
    }
  };
});

export default useAppStore;